// const express = require('express');
// const router = express.Router();
// const { Task,Comment,ArchivedTask } = require('../model/model');
// const { v4: uuidv4 } = require('uuid'); // 引入uuid库
// const cron = require('cron'); // 新增引入cron模块
// const moment = require('moment'); // 引入 moment
// // 创建任务
// router.post('/addtasks', async (req, res) => {
//   try {
//     const newTask = await Task.create(req.body);
//     res.send({
//       code: 200,
//       data: newTask,
//     });
//   } catch (err) {
//     console.log(err);
//     res.status(500).send({
//       code: 500,
      
      
//       error: err.message,
//     });
//   }
// });

// // 获取所有任务
// router.get('/tasks', async (req, res) => {
//   try {
//     // 使用sort方法按照sortOrder字段升序排序
//     const tasks = await Task.find().sort({ sortOrder: 1 }); 
//     res.json({ tasks });
//   } catch (err) {
//     res.status(500).json({ error: err.message });
//   }
// });

// // 更新任务状态
// router.put('/tasks/:id', async (req, res) => {
//   const { id } = req.params;
//   const { status, assignee } = req.body;

//   try {
//     const updateData = { status };

//     // 根据状态变更规则处理自动操作
//     if (status === 'todo') {
//       updateData.assignee = null; // 清除负责人
//     } else if (status === 'doing') {
//       updateData.assignee = assignee || '当前用户ID'; // 自动分配当前用户
//     } else if (status === 'done') {
//       updateData.completed_at = new Date(); // 记录完成时间
//     }

//     const updatedTask = await Task.findByIdAndUpdate(id, updateData, { new: true });
//     res.send({
//       code: 200,
//       data: updatedTask,
//     });
//   } catch (err) {
//     res.status(500).send({
//       code: 500,
//       error: err.message,
//     });
//   }
// });

// // 更新任务顺序
// router.put('/tasks/order', async (req, res) => {
//   const { taskIds } = req.body;
//   try {
//     for (let i = 0; i < taskIds.length; i++) {
//       const taskId = taskIds[i];
//       await Task.findByIdAndUpdate(taskId, { sortOrder: i }, { new: true });
//     }
//     const updatedTasks = await Task.find().sort({ sortOrder: 1 }); // 获取更新后的任务列表
//     res.send({
//       code: 200,
//       data: updatedTasks, // 返回更新后的任务列表
//       message: 'Task order updated successfully',
//     });
//   } catch (err) {
//     res.status(500).send({
//       code: 500,
//       error: err.message,
//     });
//   }
// });
// // 获取任务的评论
// router.get('/comments/:taskId', async (req, res) => {
//   try {
//     const comments = await Comment.find({ task_id: req.params.taskId });
//     res.json({ comments });
//   } catch (err) {
//     res.status(500).json({ error: err.message });
//   }
// });



// router.post('/comments', async (req, res) => {
//   try {
//     // 验证必填字段
//     if (!req.body.content ||!req.body.task_id ||!req.body.user_id) {
//       return res.status(400).send({
//         code: 400,
//         error: 'content, task_id and user_id are required'
//       });
//     }
//     const newId = uuidv4(); // 生成唯一的id
//     const newComment = await Comment.create({
//       id: newId,
//       ...req.body
//     });
//     res.send({
//       code: 200,
//       data: newComment,
//       message: 'Comment created successfully'
//     });
//   } catch (err) {
//     console.error('Error creating comment:', err); // 记录详细错误信息
//     res.status(500).send({
//       code: 500,
//       error: err.message
//     });
//   }
// });
// // 定义定时任务
// const archiveTasksJob = new cron.CronJob('0 0 0 * * *', async () => {
//   const threeDaysAgo = new Date();
//   threeDaysAgo.setDate(threeDaysAgo.getDate() - 3);
//   try {
//     // 查找状态为done且completed_at在3天前的任务
//     const tasksToArchive = await Task.find({
//       status: 'done',
//       completed_at: { $lt: threeDaysAgo }
//     });
//     for (const task of tasksToArchive) {
//       // 将任务插入到归档任务表
//       await ArchivedTask.create(task);
//       // 从原任务表中删除该任务
//       await Task.findByIdAndDelete(task._id);
//     }
//     console.log('自动归档任务完成');
//   } catch (error) {
//     console.error('自动归档任务出错:', error);
//   }
// });

// // 启动定时任务
// archiveTasksJob.start(); // 新增启动定时任务的代码

// // 手动归档任务接口
// router.post('/archive/:taskId', async (req, res) => {
//   const taskId = req.params.taskId;
//   try {
//     const task = await Task.findById(taskId);
//     if (!task) {
//       return res.status(404).send({ message: '任务未找到' });
//     }
//     const archivedTaskData = {
//       ...task._doc,
//       dueDate: new Date(task.dueDate),
//       completed_at: task.completed_at? new Date(task.completed_at) : null,
//     };
//     try {
//       // 将任务插入到归档任务表
//       await ArchivedTask.create(archivedTaskData);
//     } catch (createError) {
//       console.error('创建归档任务出错:', createError);
//       return res.status(500).send({ message: '创建归档任务出错', error: createError.message });
//     }
//     try {
//       // 从原任务表中删除该任务
//       const deleteResult = await Task.findByIdAndDelete(taskId);
//       if (!deleteResult) {
//         console.error('删除原任务时，未找到对应任务:', taskId);
//         return res.status(500).send({ message: '删除原任务出错', error: '未找到对应任务' });
//       }
//     } catch (deleteError) {
//       console.error('删除原任务出错:', deleteError);
//       return res.status(500).send({ message: '删除原任务出错', error: deleteError.message });
//     }
//     res.send({ message: '任务已成功归档' });
//   } catch (error) {
//     console.error('归档任务出错:', error);
//     res.status(500).send({ message: '归档任务出错', error: error.message });
//   }
// });

// // 获取归档任务接口
// // router.get('/archivedTasks', async (req, res) => {
// //   try {
// //     const archivedTasks = await ArchivedTask.find();
// //     res.send({ archivedTasks });
// //   } catch (error) {
// //     res.status(500).send({ message: '获取归档任务出错', error: error.message });
// //   }
// // });
// router.get('/archivedTasks', async (req, res) => {
//   try {
//     const archivedTasks = await ArchivedTask.find();
//     const formattedTasks = archivedTasks.map(task => {
//       return {
//         ...task._doc,
//         dueDate: moment(task.dueDate).format('YYYY-MM-DD HH:mm:ss'),
//         completed_at: task.completed_at? moment(task.completed_at).format('YYYY-MM-DD HH:mm:ss') : '无',
//         archived_at: moment(task.archived_at).format('YYYY-MM-DD HH:mm:ss')
//       };
//     });
//     res.send({ archivedTasks: formattedTasks });
//   } catch (error) {
//     res.status(500).send({ message: '获取归档任务出错', error: error.message });
//   }
// });

// router.post('/restore/:archivedTaskId', async (req, res) => {
//   const archivedTaskId = req.params.archivedTaskId;
//   try {
//     const archivedTask = await ArchivedTask.findById(archivedTaskId);
//     if (!archivedTask) {
//       return res.status(404).send({ message: '归档任务未找到' });
//     }
//     // 从归档任务表中删除该任务
//     await ArchivedTask.findByIdAndDelete(archivedTaskId);
//     // 格式化时间字段
//     const taskData = {
//       ...archivedTask._doc,
//       dueDate: moment(archivedTask.dueDate).format('YYYY-MM-DD HH:mm:ss'),
//       completed_at: archivedTask.completed_at? moment(archivedTask.completed_at).format('YYYY-MM-DD HH:mm:ss') : null,
//       archived_at: null // 恢复时不需要 archived_at 字段
//     };
//     // 将任务重新插入原任务表
//     await Task.create(taskData);
//     res.send({ message: '任务已成功恢复' });
//   } catch (error) {
//     console.error('恢复任务出错:', error);
//     res.status(500).send({ message: '恢复任务出错', error: error.message });
//   }
// });
// module.exports = router;



const express = require('express');
const router = express.Router();
const { Task,Comment,ArchivedTask } = require('../model/model');
const { v4: uuidv4 } = require('uuid'); // 引入uuid库
const cron = require('cron'); // 新增引入cron模块
const moment = require('moment'); // 引入 moment
// 创建任务
router.post('/addtasks', async (req, res) => {
  try {
    const newTask = await Task.create(req.body);
    res.send({
      code: 200,
      data: newTask,
    });
  } catch (err) {
    console.log(err);
    res.status(500).send({
      code: 500,
      
      
      error: err.message,
    });
  }
});

// 获取所有任务
router.get('/tasks', async (req, res) => {
  try {
    // 使用sort方法按照sortOrder字段升序排序
    const tasks = await Task.find().sort({ sortOrder: 1 }); 
    res.json({ tasks });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 更新任务状态
router.put('/tasks/:id', async (req, res) => {
  const { id } = req.params;
  const { status, assignee } = req.body;

  try {
    const updateData = { status };

    // 根据状态变更规则处理自动操作
    if (status === 'todo') {
      updateData.assignee = null; // 清除负责人
    } else if (status === 'doing') {
      updateData.assignee = assignee || '当前用户ID'; // 自动分配当前用户
    } else if (status === 'done') {
      updateData.completed_at = new Date(); // 记录完成时间
    }

    const updatedTask = await Task.findByIdAndUpdate(id, updateData, { new: true });
    res.send({
      code: 200,
      data: updatedTask,
    });
  } catch (err) {
    res.status(500).send({
      code: 500,
      error: err.message,
    });
  }
});

// 更新任务顺序
router.put('/tasks/order', async (req, res) => {
  const { taskIds } = req.body;
  try {
    for (let i = 0; i < taskIds.length; i++) {
      const taskId = taskIds[i];
      await Task.findByIdAndUpdate(taskId, { sortOrder: i }, { new: true });
    }
    const updatedTasks = await Task.find().sort({ sortOrder: 1 }); // 获取更新后的任务列表
    res.send({
      code: 200,
      data: updatedTasks, // 返回更新后的任务列表
      message: 'Task order updated successfully',
    });
  } catch (err) {
    res.status(500).send({
      code: 500,
      error: err.message,
    });
  }
});
// 获取任务的评论
router.get('/comments/:taskId', async (req, res) => {
  try {
    const comments = await Comment.find({ task_id: req.params.taskId });
    res.json({ comments });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

router.post('/comments', async (req, res) => {
  try {
    // 验证必填字段
    if (!req.body.content ||!req.body.task_id ||!req.body.user_id) {
      return res.status(400).send({
        code: 400,
        error: 'content, task_id and user_id are required'
      });
    }
    const newId = uuidv4(); // 生成唯一的id
    const newComment = await Comment.create({
      id: newId,
      ...req.body
    });
    res.send({
      code: 200,
      data: newComment,
      message: 'Comment created successfully'
    });
  } catch (err) {
    console.error('Error creating comment:', err); // 记录详细错误信息
    res.status(500).send({
      code: 500,
      error: err.message
    });
  }
});
// 定义定时任务
const archiveTasksJob = new cron.CronJob('0 0 0 * * *', async () => {
  const threeDaysAgo = new Date();
  threeDaysAgo.setDate(threeDaysAgo.getDate() - 3);
  try {
    // 查找状态为done且completed_at在3天前的任务
    const tasksToArchive = await Task.find({
      status: 'done',
      completed_at: { $lt: threeDaysAgo }
    });
    for (const task of tasksToArchive) {
      // 将任务插入到归档任务表
      await ArchivedTask.create(task);
      // 从原任务表中删除该任务
      await Task.findByIdAndDelete(task._id);
    }
    console.log('自动归档任务完成');
  } catch (error) {
    console.error('自动归档任务出错:', error);
  }
});

// 启动定时任务
archiveTasksJob.start(); // 新增启动定时任务的代码

// 手动归档任务接口
router.post('/archive/:taskId', async (req, res) => {
  const taskId = req.params.taskId;
  try {
    const task = await Task.findById(taskId);
    if (!task) {
      return res.status(404).send({ message: '任务未找到' });
    }
    const archivedTaskData = {
      ...task._doc,
      dueDate: new Date(task.dueDate),
      completed_at: task.completed_at? new Date(task.completed_at) : null,
    };
    try {
      // 将任务插入到归档任务表
      await ArchivedTask.create(archivedTaskData);
    } catch (createError) {
      console.error('创建归档任务出错:', createError);
      return res.status(500).send({ message: '创建归档任务出错', error: createError.message });
    }
    try {
      // 从原任务表中删除该任务
      const deleteResult = await Task.findByIdAndDelete(taskId);
      if (!deleteResult) {
        console.error('删除原任务时，未找到对应任务:', taskId);
        return res.status(500).send({ message: '删除原任务出错', error: '未找到对应任务' });
      }
    } catch (deleteError) {
      console.error('删除原任务出错:', deleteError);
      return res.status(500).send({ message: '删除原任务出错', error: deleteError.message });
    }
    res.send({ message: '任务已成功归档' });
  } catch (error) {
    console.error('归档任务出错:', error);
    res.status(500).send({ message: '归档任务出错', error: error.message });
  }
});

// 获取归档任务接口
// router.get('/archivedTasks', async (req, res) => {
//   try {
//     const archivedTasks = await ArchivedTask.find();
//     res.send({ archivedTasks });
//   } catch (error) {
//     res.status(500).send({ message: '获取归档任务出错', error: error.message });
//   }
// });
router.get('/archivedTasks', async (req, res) => {
  try {
    const archivedTasks = await ArchivedTask.find();
    const formattedTasks = archivedTasks.map(task => {
      return {
        ...task._doc,
        dueDate: moment(task.dueDate).format('YYYY-MM-DD HH:mm:ss'),
        completed_at: task.completed_at? moment(task.completed_at).format('YYYY-MM-DD HH:mm:ss') : '无',
        archived_at: moment(task.archived_at).format('YYYY-MM-DD HH:mm:ss')
      };
    });
    res.send({ archivedTasks: formattedTasks });
  } catch (error) {
    res.status(500).send({ message: '获取归档任务出错', error: error.message });
  }
});

router.post('/restore/:archivedTaskId', async (req, res) => {
  const archivedTaskId = req.params.archivedTaskId;
  try {
    const archivedTask = await ArchivedTask.findById(archivedTaskId);
    if (!archivedTask) {
      return res.status(404).send({ message: '归档任务未找到' });
    }
    // 从归档任务表中删除该任务
    await ArchivedTask.findByIdAndDelete(archivedTaskId);
    // 格式化时间字段
    const taskData = {
      ...archivedTask._doc,
      dueDate: moment(archivedTask.dueDate).format('YYYY-MM-DD HH:mm:ss'),
      completed_at: archivedTask.completed_at? moment(archivedTask.completed_at).format('YYYY-MM-DD HH:mm:ss') : null,
      archived_at: null // 恢复时不需要 archived_at 字段
    };
    // 将任务重新插入原任务表
    await Task.create(taskData);
    res.send({ message: '任务已成功恢复' });
  } catch (error) {
    console.error('恢复任务出错:', error);
    res.status(500).send({ message: '恢复任务出错', error: error.message });
  }
});
module.exports = router;